#pragma once 
#include <iostream>
#include <vector>
#include <cassert>
#include <cstring>
#include <stdarg.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include <sys/epoll.h>
#include <unordered_map>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <typeinfo>
#include <signal.h>

#define SIZE    1024
// 日志等级
#define Info    0
#define Debug   1
#define Warning 2
#define Error   3
#define Fatal   4
// 打印位置
#define Screen 1
#define Onefile 2
#define Classfile 3
#define LogFile "log.txt"

// 缓冲区
class Buffer
{
public:
    Buffer(int size=1024):_buffer(size),_writer_idx(0),_reader_idx(0)
    {}
    // 若只构造可读数据, WriteAndPush(bf);
    Buffer(const Buffer& bf)
    :_buffer(bf._buffer),_writer_idx(bf._writer_idx),_reader_idx(bf._reader_idx)
    {/*WriteAndPush(bf);*/}
    Buffer& operator=(const Buffer& bf)
    {
        // WriteAndPush(bf);
        if (this==&bf) return *this;
        _buffer=bf._buffer;
        _writer_idx=bf._writer_idx;
        _reader_idx=bf._reader_idx;
        return *this;
    }
public:
    char* Begin() {return &*_buffer.begin();}  // 不是返回迭代器
    const char* Begin() const {return &*_buffer.begin();} // 不是返回迭代器
    // 获取当前写地址
    char* WritePos() {return Begin()+_writer_idx;}
    const char* WritePos() const {return Begin()+_writer_idx;}
    // 获取当前读地址
    char* ReadPos() {return Begin()+_reader_idx;}
    const char* ReadPos() const {return Begin()+_reader_idx;}
    // 获取尾部可写空间大小
    uint64_t TailWritableSize() const {return _buffer.size()-_writer_idx;}
    // 获取头部可写空间大小
    uint64_t HeadWritableSize() const {return _reader_idx;}
    // 获取可读数据大小
    uint64_t ReadableSize() const {return _writer_idx-_reader_idx;}
    // 读偏移向后移动
    void MoveReadOffset(uint64_t len)
    {
        if (len==0) return;
        assert(len<=ReadableSize());
        _reader_idx+=len;
    }
    // 写偏移向后移动
    void MoveWriteOffset(uint64_t len)
    {
        if (len==0) return;
        // 写指针是一直往后写的，只管后面空间够不够
        assert(len<=TailWritableSize());
        _writer_idx+=len;
    }
    // 保证足够空间可写
    void EnsureWriteable(uint64_t len)
    {
        if (len<=TailWritableSize()) return;
        else if (len <= HeadWritableSize()+TailWritableSize())
        {
            int rsz=ReadableSize();
            std::copy(ReadPos(),ReadPos()+rsz,Begin());
            _reader_idx=0,_writer_idx=rsz;
        }
        else
        {
            // 总体空间扩容
            _buffer.resize(_writer_idx+len);
        }
    }

public:
    // 原生写入接口
    void Write(const void* buf,uint64_t len)
    {
        if (len==0) return;
        EnsureWriteable(len);
        std::copy((const char*)buf,(const char*)buf+len,WritePos());
    }
    void WriteAndPush(const void* buf,uint64_t len)
    {
        Write(buf,len);
        MoveWriteOffset(len);
    }
    // 写入str
    void Write(const std::string& str) {Write(str.c_str(),str.size());}
    void WriteAndPush(const std::string& str) {WriteAndPush(str.c_str(),str.size());}
    // 写入buffer对象
    void Write(const Buffer& bf)
    {
        if (&bf==this) return;
        Write(bf.ReadPos(),bf.ReadableSize());
    }
    void WriteAndPush(const Buffer& bf) {WriteAndPush(bf.ReadPos(),bf.ReadableSize());/* 允许进行自我拷贝*/}
    // 原生读取接口
    void Read(void* buf,uint64_t len) const
    {
        assert(len<=ReadableSize());
        std::copy(ReadPos(),ReadPos()+len,(char*)buf);
    }
    void ReadAndPop(void* buf,uint64_t len)
    {
        Read(buf,len);
        MoveReadOffset(len);
    }
    // 读取string
    std::string ReadAsString(uint64_t len) const
    {
        std::string tmp;
        tmp.resize(len); /*c_str是const的,必须resize不然string大小没有被修改*/
        Read(&tmp[0],len);
        return tmp;
    }
    std::string ReadAsStringAndPop(uint64_t len)
    {
        std::string tmp;
        tmp.resize(len); /*c_str是const的,必须resize不然string大小没有被修改*/
        ReadAndPop(&tmp[0],len);
        return tmp;
    }
    // 查找'\n'
    const char* FindCRCF() const {return (const char*)memchr(ReadPos(),'\n',ReadableSize());}
    // 获取一行数据包括\n
    std::string GetLine() const
    {
        const char *pos=FindCRCF();
        if (pos==nullptr) return "";
        return ReadAsString(pos - ReadPos()+1);
    }
    std::string GetLineAndPop()
    {
        const char *pos=FindCRCF();
        if (pos==nullptr) return "";
        return ReadAsStringAndPop(pos - ReadPos()+1);
    }
    // 清空缓冲区
    void Clear()
    {
        _writer_idx=0;
        _reader_idx=0;
    }
    // For Debug
    void Print() const
    {
        for(int i=0;i<ReadableSize();i++)
            std::cout<<_buffer[i+_reader_idx];
    }
    // 获取可读空间大小
    uint64_t GetReadableSize() const {return ReadableSize();}

private:
    std::vector<char> _buffer;
    uint64_t _writer_idx;  // 写偏移
    uint64_t _reader_idx;  // 读偏移
};
// 日志
class Log
{
public:
    Log()
    {}
    // 选择输出方式
    void select_way(int method) {way = method;}
    // 选择输出路径
    void select_path(std::string newpath) {path=newpath;}
    // ()重载
    void operator()(int level, const char *format, ...)
    {
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        // 左边固定部分
        char leftbuff[SIZE];
        snprintf(leftbuff, sizeof(leftbuff), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(), ctime->tm_year + 1900,
                 ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
        va_list s;
        va_start(s, format); // 让s指向可变部分

        // 右边可变部分
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);
        char buff[SIZE * 2];
        snprintf(buff, sizeof(buff), "%s %s\n", leftbuff, rightbuffer);

        printLog(level,buff);
    }
private:
    // 宏转字符串
    std::string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "None";
        }
    }
    // 输出
    void printLog(int level,std::string logtxt)
    {
        switch (way)
        {
        case Screen:
            std::cout << logtxt ;
            break;
        case Onefile:
            printOneFile(LogFile,logtxt);
            break;
        case Classfile:
            printClassFile(level,logtxt);
            break;
        default:
            break;
        }
    }
    // 目录不存在，创建目录
    void ensureDirectoryExists(const std::string& dirPath) {
        struct stat info;
        if (stat(dirPath.c_str(), &info) != 0 || !(info.st_mode & S_IFDIR)) {
            // 目录不存在，创建目录
            mkdir(dirPath.c_str(), 0755);
        }
    }
    // 单文件输出
    void printOneFile(const std::string &logname,const std::string &logtxt)
    {
        ensureDirectoryExists(path); 
        if (*path.end()!='/') path+="/";
        std::string newpath=path+logname;
        int fd = open(newpath.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
        if (fd<0) return ;
        write(fd,logtxt.c_str(),logtxt.size());
        close(fd);
    }
    // 多文件输出
    void printClassFile(int level,const std::string &logtxt)
    {
        std::string filename = LogFile;
        filename += ".";
        filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
        printOneFile(filename, logtxt);
    }

private:
    int way= Screen;          // 选择打印方式
    std::string path= "./";   // 路径
};
Log lg;
// 套接字
class Socket 
{   
public:
    Socket():_sockfd(-1) {}
    Socket(int fd): _sockfd(fd){}
    ~Socket() {Close();}
    // 获取描述符
    int Fd() {return _sockfd;}
    // 创建套接字
    bool Create() 
    {
        // int socket(int domain, int type, int protocol)
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            lg(Error, "Creat Socket Error %d: %s", errno, strerror(errno));
            return false;
        }
        return true;
    }
    // 绑定
    bool Bind(const std::string &ip, uint16_t port) 
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0) 
        {
            lg(Error, "Bind Error %d: %s", errno, strerror(errno));
            return false;
        }
        return true;
    }
    // 监听
    bool Listen(int backlog = 1024) 
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            lg(Error, "Listen Error %d: %s", errno, strerror(errno));
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port) 
    {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;  
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0) 
        {
            lg(Error, "Connect Error %d: %s", errno, strerror(errno));
            return false;
        }
        return true;
    }       
    // 可以可以关注一下客户端ip和端口号
    int Accept(char* ip, size_t ipsize, uint16_t port)
    {
        sockaddr_in client;
        socklen_t len=sizeof(client);
        int newfd=accept(_sockfd, (sockaddr*)&client,&len);
        if (newfd<0)
        {
            lg(Error, "Accept Error %d: %s", errno, strerror(errno));
            return -1;
        }
        ip=inet_ntoa(client.sin_addr);
        port=client.sin_port;
        return newfd;
    }
    // 获取新连接
    int Accept() 
    {
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0) 
        {
            lg(Error, "Accept Error %d: %s", errno, strerror(errno));
            return -1;
        }
        return newfd;
    }
    //接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0)
    {
        ssize_t n = recv(_sockfd, buf, len, flag);
        if (n <= 0) 
        {
            //EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            //EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR) return 0;
            if (n == 0) { // 对端关闭连接
                lg(Warning,"The other side has closed the connection!!!");
                return -1; 
            }
            lg(Error,"Socket Recv Error %d: %s", errno, strerror(errno));
        }
        return n; //实际接收的数据长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len) {return Recv(buf, len, MSG_DONTWAIT);}
    //发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0) 
    {
        ssize_t n = send(_sockfd, buf, len, flag);
        if (n < 0)
        {
            if (errno == EAGAIN || errno == EINTR) return 0;
            lg(Error,"Socket Send Error %d: %s", errno, strerror(errno));
            return -1;
        }
        return n;//实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len) 
    {
        if (len == 0) return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前发送为非阻塞。
    }
    //创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) 
    {
        //1. 创建套接字，2. 绑定地址，3. 开始监听，4. 设置非阻塞， 5. 启动地址重用
        if (!Create()) return false;
        if (block_flag) SetNonBlock();
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt));
        if (!Bind(ip, port)) return false;
        if (!Listen()) return false;
        return true;
    }
    //创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip) 
    {
        //1. 创建套接字，2.指向连接服务器
        if (Create() == false) return false;
        if (Connect(ip, port) == false) return false;
        return true;
    }
    //设置套接字阻塞属性-- 设置为非阻塞
    void SetNonBlock() 
    {
        int fl = fcntl(_sockfd, F_GETFL);
        if (fl < 0)
        {
            perror("fcntl");
            return;
        }
        fcntl(_sockfd, F_SETFL, fl | O_NONBLOCK);
    }
    //关闭套接字
    void Close() 
    {
        if (_sockfd != -1) 
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }

private:
    int _sockfd;
};
// 提前声明
class EventLoop;
// 对事件进行管理
class Channel 
{
    using EventCallBack = std::function<void()>;
public:
    Channel(EventLoop *loop, int fd):_fd(fd), _loop(loop) {}
    int Fd() {return _fd;}
    uint32_t Events() {return _events;}//获取想要监控的事件
    // 设置实际就绪的事件
    void SetRevents(uint32_t events) {_revents = events;}
    // 当前是否可读
    bool IsReadAble() {return (_events & EPOLLIN);} 
     // 当前是否可写
    bool IsWriteAble() {return (_events & EPOLLOUT);}
    // 监控可读
    void MonitorRead() {_events |= EPOLLIN; Update();}
    // 监控可写
    void MonitorWrite() {_events |= EPOLLOUT; Update();}
    // 取消可读监控
    void UnMonitorRead() {_events &= ~EPOLLIN; Update();}
    // 取消可写监控
    void UnMonitorWrite() {_events &= ~EPOLLOUT; Update();}
    // 关闭所有事件监控
    void UnMonitorAll() {_events = 0; Update();}
    // 更新ep模型
    void Update();
    // 从ep模型中移除自己
    void Remove();
    //  处理事件
    void HandleEvent() 
    {
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) 
        {
            if (_readcb) _readcb();
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if ((_revents & EPOLLOUT) && _writecb) _writecb();
        else if ((_revents & EPOLLERR) && _errorcb)  _errorcb();
        else if ((_revents & EPOLLHUP) && _closecb)  _closecb();
        if (_eventcb) _eventcb();
    }
    // 设置读写等各种回调 
    void SetReadCallBack(const EventCallBack &cb) {_readcb = cb;}
    void SetWriteCallBack(const EventCallBack &cb) {_writecb = cb;}
    void SetErrorCallBack(const EventCallBack &cb) {_errorcb = cb;}
    void SetCloseCallBack(const EventCallBack &cb) {_closecb = cb;}
    void SetEventCallBack(const EventCallBack &cb) {_eventcb = cb;}

private:
    int _fd;
    EventLoop *_loop;
    uint32_t _events=0;  // 当前需要监控的事件
    uint32_t _revents=0; // 当前连接触发的事件
    EventCallBack _readcb=nullptr;   //可读事件被触发的回调函数
    EventCallBack _writecb=nullptr;  //可写事件被触发的回调函数
    EventCallBack _errorcb=nullptr;  //错误事件被触发的回调函数
    EventCallBack _closecb=nullptr;  //连接断开事件被触发的回调函数
    EventCallBack _eventcb=nullptr;  //任意事件被触发的回调函数
};
// 对channel进行管理
class Epoller 
{
public:
    Epoller() 
    {
        _epfd = epoll_create(1024);
        if (_epfd < 0) 
        {
            lg(Fatal, "Epoll_Create Error: %s,Line: %d", strerror(errno),__LINE__);
            std::cout<<__LINE__,abort();//退出程序
        }
    }
    // 更新Epoll模型
    void UpdateEvent(Channel *channel) 
    {
        bool ret = IsExist(channel);
        if (ret == false) 
        {
            //不存在则添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 从Epoll模型中删除
    void RemoveEvent(Channel *channel) 
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())  _channels.erase(it);
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控
    void EpollerWait(std::vector<Channel*> *active) 
    {
        int nfds = epoll_wait(_epfd, _evs, 1024, -1);
        if (nfds < 0)
        {
            if (errno == EINTR) return ;
            lg(Fatal, "Epoll_Wait Error: %s,Line: %d", strerror(errno),__LINE__);
            std::cout<<__LINE__,abort();//退出程序
        }
        for (int i = 0; i < nfds; i++) 
        {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetRevents(_evs[i].events);//设置实际就绪的事件
            active->push_back(it->second);
        }
    }

private:
    // 对epoll的直接操作
    void Update(Channel *channel, int op) 
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;// 方便我们后续得知,是哪一个fd就绪了
        ev.events = channel->Events();
        int n = epoll_ctl(_epfd, op, fd, &ev);
        if (n < 0) lg(Fatal, "Epoll_Ctl Error %d: %s, Line: %d", errno, strerror(errno),__LINE__);
    }
    // 当前Channel对象是否存在
    bool IsExist(Channel *channel) 
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end()) return false;
        return true;
    }
private:
    int _epfd;
    struct epoll_event _evs[1024];
    std::unordered_map<int, Channel *> _channels;
};
// 定时器
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class TimerTask
{
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb)
    : _id(id), _timeout(delay), _task_cb(cb), _canceled(false)
    {}
    // 取消定时器
    void Cancel() {_canceled = true;}
    // 设则释放定时器回调
    void SetRelease(const ReleaseFunc &cb) {_release = cb;}
    // 获取超时时间
    uint32_t DelayTime() {return _timeout;}
    ~TimerTask() 
    { 
        // 如果任务没有被取消，则执行任务，只有对象被销毁时才执行任务
        if (_canceled == false) _task_cb(); 
        _release(); 
    }
private:
    uint64_t _id;       // 定时器任务对象ID
    uint32_t _timeout;  //定时任务的超时时间
    bool _canceled;     // false-表示没有被取消， true-表示被取消
    TaskFunc _task_cb;  //定时器对象要执行的定时任务
    ReleaseFunc _release; //用于删除TimerWheel中保存的定时器对象信息
};
// 时间轮
class TimerWheel 
{
    using WeakTask = std::weak_ptr<TimerTask>;
    // 方便更新任务时间，同时解决循环引用问题，避免定时器永远不会为0
    using PtrTask = std::shared_ptr<TimerTask>;
public:
    TimerWheel(EventLoop *loop):_capacity(60), _wheel(_capacity), _loop(loop), 
        _timerfd(CreateTimerfd()), _timer_channel(new Channel(_loop, _timerfd)) 
    {
        _timer_channel->SetReadCallBack(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->MonitorRead();//启动读事件监控
    }
    // 定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题
    // 如果不想加锁，那就把对定期的所有操作，都放到一个线程中进行
    // 添加定时器  
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新定时器 
    void TimerRefresh(uint64_t id);
    // 取消定时器
    void TimerCancel(uint64_t id);
    // 下面这个接口存在线程安全,我们只在模块内使用
    bool HasTimer(uint64_t id) 
    {
        auto it = _hash.find(id);
        if (it == _hash.end()) return false;
        return true;
    }
private:
    // 从hash表中移除
    void RemoveTimer(uint64_t id)
    {
        auto it = _hash.find(id);
        if (it != _hash.end()) _hash.erase(it);
    }
    // 创建定时器文件描述符
    static int CreateTimerfd() 
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            lg(Fatal,"CreateTimerfd Failed!!! Line: %d",__LINE__);
            std::cout<<__LINE__,abort();
        }
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0;//第一次超时时间为1s后
        itime.it_interval.tv_sec = 1; 
        itime.it_interval.tv_nsec = 0; //第一次超时后，每次超时的间隔时
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }
    // 读取超时次数
    int ReadTimefd() 
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0) 
        {
            lg(Fatal,"ReadTimerFd Failed!! Line: %d",__LINE__);
            std::cout<<__LINE__,abort();
        }
        return times;
    }
    // 这个函数应该每秒钟被执行一次，相当于秒针向后走了一步
    void RunTimerTask() 
    {
        _cursor = (_cursor + 1) % _capacity;
        _wheel[_cursor].clear();//清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }
    // 时间一到执行任务
    void OnTime() 
    {
        //根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++) RunTimerTask();
    }
    // 添加定时器放入到EventLoop任务池中,避免线程安全问题
    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) 
    {
        PtrTask pt(new TimerTask(id, delay, cb));
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));
        int pos = (_cursor + delay) % _capacity;
        _wheel[pos].push_back(pt);
        _hash[id] = WeakTask(pt);
    }
    // 刷新定时器放入到EventLoop任务池中,避免线程安全问题
    void TimerRefreshInLoop(uint64_t id) 
    {
        //通过保存的定时器对象的weak_ptr构造一个shared_ptr出来，添加到轮子中
        auto it = _hash.find(id);
        if (it == _hash.end()) return;//没找着定时任务，没法刷新，没法延迟
        PtrTask pt = it->second.lock();//lock获取weak_ptr管理的对象对应的shared_ptr
        int delay = pt->DelayTime();
        int pos = (_cursor + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    // 取消定时器任务放入到EventLoop任务池中,避免线程安全问题
    void TimerCancelInLoop(uint64_t id) 
    {
        auto it = _hash.find(id);
        if (it == _hash.end()) return;//没找着定时任务，没法刷新，没法延迟
        PtrTask pt = it->second.lock();
        if (pt) pt->Cancel();
    }

private:
    int _cursor=0;      // 时间轮光标
    int _capacity=60;    // 时间轮长度
    std::vector<std::vector<PtrTask>> _wheel;   // 存放同一时刻的一批定时器
    std::unordered_map<uint64_t, WeakTask> _hash;  // 方便找到某个定时器
    EventLoop *_loop;   // 通过事件的方式来控制
    int _timerfd;       // 定时器描述符
    std::unique_ptr<Channel> _timer_channel;
};
// 事件循环
class EventLoop 
{
    using Functor = std::function<void()>;
public:
    // 执行任务池中的任务
    void RunAllTask() 
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _task_pool.swap(functor);
        }
        for (auto &f : functor) f();
        return ;
    }
    // 创建eventfd
    static int CreateEventFd() 
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0) {
            lg(Fatal,"CreateEventFd Failed!! Line: %d",__LINE__);
            std::cout<<__LINE__,abort();//让程序异常退出
        }
        return efd;
    }
    // 为eventfd设置读方法
    void ReadEventfd() 
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0) {
            // EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)  return;
            lg(Fatal,"ReadEventFd Failed!! Line: %d",__LINE__);
            std::cout<<__LINE__,abort();
        }
        return ;
    }
    // 唤醒eventfd
    void WeakUpEventFd() 
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR) return;
            lg(Fatal,"WeakUpEventFd Faild!! Line: %d",__LINE__);
            std::cout<<__LINE__,abort();
        }
        return ;
    }
public:
    EventLoop()
    :_thread_id(std::this_thread::get_id()), _event_fd(CreateEventFd()), 
    _event_channel(new Channel(this, _event_fd)),_timer_wheel(this) 
    {
        // 给eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _event_channel->SetReadCallBack(std::bind(&EventLoop::ReadEventfd, this));
        _event_channel->MonitorRead();
    }
    // 主流程
    void Start() 
    {
        while(1) 
        {
            //1. 事件监控， 
            std::vector<Channel *> actives;
            _poller.EpollerWait(&actives);
            //2. 事件处理。 
            for (auto &channel : actives) channel->HandleEvent();
            //3. 执行任务
            RunAllTask();
        }
    }
    // 判断当前线程是不是在eventloop线程中
    bool IsInLoop() {return (_thread_id == std::this_thread::get_id());}
    void AssertInLoop() {assert(_thread_id == std::this_thread::get_id());}
    // 当前线程时eventloop线程,则直接执行,否则放入任务池 
    void RunInLoop(const Functor &cb) 
    {
        if (IsInLoop()) return cb();
        return PushInTaskPool(cb);
    }
    // 压入任务池 
    void PushInTaskPool(const Functor &cb) 
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _task_pool.push_back(cb);
        }
        // 防止epoll阻塞而长时间不能执行任务
        WeakUpEventFd();
    }
    //添加/修改描述符的事件监控
    void UpdateEvent(Channel *channel) {return _poller.UpdateEvent(channel);}
    //移除描述符的监控
    void RemoveEvent(Channel *channel) {return _poller.RemoveEvent(channel);}
    // 添加定时器
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) {return _timer_wheel.TimerAdd(id, delay, cb);}
    // 刷新定时器
    void TimerRefresh(uint64_t id) {return _timer_wheel.TimerRefresh(id);}
    // 取消定时器
    void TimerCancel(uint64_t id) {return _timer_wheel.TimerCancel(id);}
    // 查看定时器是否存在
    bool HasTimer(uint64_t id) {return _timer_wheel.HasTimer(id);}

private:
    std::thread::id _thread_id;         // 线程id
    int _event_fd;    // 唤醒IO事件监控而导致的阻塞
    std::unique_ptr<Channel> _event_channel;   
    Epoller _poller;    // Epoller模型进行事件监控
    std::vector<Functor> _task_pool;    // 任务池
    std::mutex _mutex;       // 任务池时临界资源锁
    TimerWheel _timer_wheel; //定时器模块
};
// 延迟实现的函数
void Channel::Remove() {return _loop->RemoveEvent(this);}
void Channel::Update() {return _loop->UpdateEvent(this);}
void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) 
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}
// 刷新/延迟定时任务
void TimerWheel::TimerRefresh(uint64_t id) 
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}
void TimerWheel::TimerCancel(uint64_t id) 
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}
// 线程和EventLoop绑定
class LoopThread 
{
public:
    // 创建线程，设定线程入口函数
    LoopThread():_loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前线程关联的loop对象指针
    EventLoop *GetLoop() 
    {
        EventLoop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            // _loop没被初始化就一直阻塞
            _cond.wait(lock, [&](){ return _loop != nullptr; });
            loop = _loop;
        }
        return loop;
    }
private:
    // 实例化 EventLoop 对象,唤醒_cond上有可能阻塞的线程,并且开始运行EventLoop模块的功能
    void ThreadEntry() 
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            // 唤醒正在阻塞的线程
            _cond.notify_all();
        }
        loop.Start();
    }
private:
    // 避免创建了线程但是还没有实例化loop就去获取loop
    std::mutex _mutex;              // 互斥锁
    std::condition_variable _cond;  // 条件变量
    EventLoop *_loop;       // EventLoop必须在线程内初始化
    std::thread _thread;    // EventLoop对应的线程
};
// 线程池
class LoopThreadPool 
{
public:
    LoopThreadPool(EventLoop *baseloop):_baseloop(baseloop) {}
    // 设置线程池数量
    void SetThreadPoolSize(int count) {_threadpoolsize = count;}
    // 线程池初始化
    void Init() 
    {
        if (_threadpoolsize > 0) 
        {
            _threads.resize(_threadpoolsize);
            _loops.resize(_threadpoolsize);
            for (int i = 0; i < _threadpoolsize; i++) 
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
        return ;
    }
    // 分配下一个loop
    EventLoop *NextLoop() 
    {
        if (_threadpoolsize == 0) return _baseloop;
        _next_idx = (_next_idx + 1) % _threadpoolsize;
        return _loops[_next_idx];
    }
private:
    EventLoop *_baseloop; // 主Reactor
    int _threadpoolsize=0;  // 线程池大小
    int _next_idx=0;      // 用于RR轮转
    std::vector<LoopThread*> _threads; // 线程池
    std::vector<EventLoop *> _loops;   // 线程池中线程一一对应的loop
};
// 通用类容器
class Any{
public:
    Any():_content(NULL) {}
    ~Any() {delete _content;}
    template<class T>
    Any(const T &val):_content(new placeholder<T>(val)) {}
    // 拷贝构造
    Any(const Any &other):_content(other._content?other._content->clone():nullptr) {}
    // 交换函数
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }
    // 返回子类对象保存的数据的指针
    template<class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T>*)_content)->_val;
    }
    // 赋值运算符的重载函数
    template<class T>
    Any& operator=(const T& val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any& operator=(const Any& other)
    {
        Any(other).swap(*this);
        return *this;
    }

private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };
    template<class T>
    class placeholder: public holder 
    {
    public:
        placeholder(const T &val): _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info& type() {return typeid(T);}
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() {return new placeholder(_val);}
    public:
        T _val;
    };
    holder *_content;
};
// 连接管理
class Connection : public std::enable_shared_from_this<Connection> 
{
    // 0.关闭状态  1.连接中状态  2.已连接状态  3.待关闭状态
    typedef enum { CLOSED, CONNECTING, CONNECTED, CLOSEING}ConnStatu;   
    using PtrConnection = std::shared_ptr<Connection>;
    using ConnectedCallBack=std::function<void(const PtrConnection&)>;
    using MessageCallBack=std::function<void(const PtrConnection&,Buffer*)>;
    using ClosedCallBack=std::function<void(const PtrConnection&)>;
    using AnyEventCallBack=std::function<void(const PtrConnection&)>;
    using ServerClosedCallBack=std::function<void(const PtrConnection&)>;
public:
    Connection(EventLoop *loop,uint64_t conn_id,int sockfd)
    :_conn_id(conn_id),_sockfd(sockfd),_enable_inactive_release(false),
    _loop(loop),_statu(CONNECTING),_socket(_sockfd), _channel(loop, _sockfd)
    {
        // 1.类内成员初始化
        // 2.完成对channel类回调函数的初始化
        _channel.SetCloseCallBack(std::bind(&Connection::HandleClose, this));
        _channel.SetEventCallBack(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallBack(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallBack(std::bind(&Connection::HandleWrite, this));
        _channel.SetErrorCallBack(std::bind(&Connection::HandleError, this));
    }
    ~Connection()  {lg(Info,"Release Connection: %p",this);}
    // 管理的文件描述符fd
    int Fd() {return _sockfd;}
    // 获取连接id和定时器id
    int Id() {return _conn_id;}
    // 是否是连接状态
    bool Connected() {return (_statu == CONNECTED);}
    // 设置上下文
    void SetContext(const Any &context) {_context = context;}
    /// 获取上下文
    Any *GetContext() {return &_context;}
    // 设置连接之后的各种回调
    void SetConnectedCallBack(const ConnectedCallBack&cb) {_connected_cb=cb;}
    void SetMessageCallBack(const MessageCallBack&cb) {_message_cb=cb;}
    void SetClosedCallBack(const ClosedCallBack&cb) {_closed_cb=cb;}
    void SetAnyEventCallBack(const AnyEventCallBack&cb) {_event_cb=cb;}
    void SetSrvClosedCallBack(const ClosedCallBack&cb) {_server_closed_cb=cb;}
    // 连接建立成功后,通过channel对事件进行监控
    void Established() {_loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));}
    // 把数据放到发送缓冲区,开启写事件监控
    void Send(const char *data, size_t len) 
    {
        //外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
        //因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buf;
        buf.WriteAndPush(data, len);
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buf)));
    }
    // 进入待释放状态 
    void Shutdown() {_loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));}
    // 释放
    void Release() {_loop->PushInTaskPool(std::bind(&Connection::ReleaseInLoop, this));}
    // 定义时间为sec的非活跃连接释放
    void SetInactiveRelease(int sec) 
    {
        _loop->RunInLoop(std::bind(&Connection::SetInactiveReleaseInLoop, this, sec));
    }
    // 取消非活跃销毁
    void CancelInactiveRelease() {_loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));}
    // 协议切换,重置上下文和阶段性处理函数
    void Upgrade(const Any &context, const ConnectedCallBack &cnnt, const MessageCallBack &msg, 
                const ClosedCallBack &closed, const AnyEventCallBack &event) 
    {
        // 必须在线程中执行,防止新事件触发后使用原协议处理数据
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, cnnt, msg, closed, event));
    }
private:
    //  连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
    void EstablishedInLoop() 
    {
        // 1.进入连接状态 
        assert(_statu == CONNECTING);
        _statu = CONNECTED;
        // 2.启动读事件监控
        _channel.MonitorRead();
        // 3.调用连接之后的回调函数
        if (_connected_cb) _connected_cb(shared_from_this());
    }
    // 文件描述符可读事件触发后要进行的操作
    void HandleRead() 
    {
        //1. 接收socket的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        //出错了,不能直接关闭连接
        if (ret < 0) return ShutdownInLoop();
        //这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        //将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        //2. 调用message_cb进行业务处理
        if (_in_buffer.ReadableSize()>0 && _message_cb) 
        {
            //shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            return _message_cb(shared_from_this(), &_in_buffer);
        }
    }
    // 文件描述符可写事件触发后要进行的操作
    void HandleWrite() 
    {
        //_out_buffer中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPos(), _out_buffer.ReadableSize());
        if (ret < 0) 
        {
            //发送错误就该关闭连接了，
            if (_in_buffer.ReadableSize()>0&&_message_cb) 
                _message_cb(shared_from_this(), &_in_buffer);
            return Release();//这时候就是实际的关闭释放操作了。
        }
        _out_buffer.MoveReadOffset(ret);//千万不要忘了，将读偏移向后移动
        if (_out_buffer.ReadableSize() == 0) 
        {
            _channel.UnMonitorWrite();// 没有数据待发送了，关闭写事件监控
            //如果当前是连接待关闭状态，则有数据，发送完数据释放连接，没有数据则直接释放
            if (_statu == CLOSEING) return Release();
        }
        return;
    }
    // 文件描述符挂断事件触发后要进行的操作
    void HandleClose() 
    {
        /*一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接*/
        if (_in_buffer.ReadableSize()>0&&_message_cb) _message_cb(shared_from_this(), &_in_buffer);
        return Release();
    }
    // 文件描述符错误事件触发后要进行的操作
    void HandleError() {return HandleClose();}
    // 文件描述符任意事件触发后要进行的操作
    void HandleEvent() 
    {
        if (_enable_inactive_release == true) {_loop->TimerRefresh(_conn_id);}
        if (_event_cb) {_event_cb(shared_from_this());}
    }
    //这个接口才是实际的释放接口
    void ReleaseInLoop() 
    {
        //1. 修改连接状态，将其置为CLOSED
        _statu = CLOSED;
        //2. 移除连接的事件监控
        _channel.Remove();
        //3. 关闭描述符
        _socket.Close();
        //4. 如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id)) CancelInactiveReleaseInLoop();
        //5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
        if (_closed_cb) _closed_cb(shared_from_this());
        //移除服务器内部管理的连接信息
        if (_server_closed_cb) _server_closed_cb(shared_from_this());
    }
    // 并不是实际的发送接口
    void SendInLoop(Buffer &buf) 
    {
        if (_statu == CLOSED) return;
        // 1.把数据放到发送缓冲区
        _out_buffer.WriteAndPush(buf);
        // 2.启动可写事件监控
        if (_channel.IsWriteAble() == false) _channel.MonitorWrite();
    }
    // 并不是实际的释放接口,需要处理收发缓冲区剩余的数据
    void ShutdownInLoop() 
    {
        // 1.进入待释放状态
        _statu = CLOSEING;
        // 2.只进行一次messagecb后都释放连接,因为接收缓冲区数据可能不完整的话,上层不会处理,
        if (_in_buffer.ReadableSize()>0&&_message_cb) 
            _message_cb(shared_from_this(), &_in_buffer);
        // 3.写入数据出错或者没有数据写入释放连接
        if (_out_buffer.ReadableSize() > 0) _channel.MonitorWrite();
        // 4.若没有数据待发送,就释放连接
        if (_out_buffer.ReadableSize() == 0) Release();
    }
    // 定义时间为sec的非活跃连接释放
    void SetInactiveReleaseInLoop(int sec) 
    {
        // 1.修改标志位
        _enable_inactive_release = true;
        // 2.判断定时销毁任务是否存在,存在就刷新,不存在就新增
        if (_loop->HasTimer(_conn_id)) return _loop->TimerRefresh(_conn_id);
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
    }
    // 取消非活跃销毁
    void CancelInactiveReleaseInLoop() 
    {
        // 1.修改标志位
        _enable_inactive_release = false;
        // 2.判断定时销毁任务是否存在,存在就取消
        if (_loop->HasTimer(_conn_id)) _loop->TimerCancel(_conn_id); 
    }
    // 协议切换,重置上下文和阶段性处理函数
    void UpgradeInLoop(const Any &context, const ConnectedCallBack &cnnt, 
    const MessageCallBack &msg, const ClosedCallBack &closed, const AnyEventCallBack &event) 
    {
        _context = context;
        _connected_cb = cnnt;
        _message_cb = msg;
        _closed_cb = closed;
        _event_cb = event;
    }

private:
    // 为了简化操作,_connect_id也当作定时器id来使用
    uint64_t _conn_id;  // 连接id
    int _sockfd;        // 连接关联的文件描述符
    bool _enable_inactive_release;  // 是否启动非活跃连接释放
    EventLoop *_loop;   // 回指向loop
    ConnStatu _statu;   // 连接状态
    Socket _socket;     // 套接字操作管理
    Channel _channel;   // 连接的事件管理
    Buffer _in_buffer;  // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buffer; // 输出缓冲区---存放要发送给对端的数据
    Any _context;       // 请求的接收处理上下文
    ConnectedCallBack _connected_cb;  // 连接成功后的回调
    MessageCallBack _message_cb;      // 业务处理回调
    ClosedCallBack _closed_cb;        // 释放连接回调
    AnyEventCallBack _event_cb;       // 任意事件回调
    /*组件内的连释放回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，
    一旦某个连接要释放, 就应该从管理的地方移除掉自己的信息*/
    ServerClosedCallBack _server_closed_cb;
};
// 主Reactor对新连接的管理
class Acceptor 
{
    using AcceptCallBack = std::function<void(int)>;
public:
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
    Acceptor(EventLoop *loop, int port)
    : _socket(CreateServer(port)), _loop(loop), _channel(loop, _socket.Fd()) 
    {
        _channel.SetReadCallBack(std::bind(&Acceptor::HandleRead, this));
    }
    // 设置新连接要执行的操作
    void SetAcceptCallBack(const AcceptCallBack &cb) {_accept_cb = cb;}
    // 监控读事件
    void Listen() {_channel.MonitorRead();}
private:
    void HandleRead() 
    {
        int newfd = _socket.Accept();
        if (newfd < 0) return;
        if (_accept_cb) _accept_cb(newfd);
    }
    // 创建server,返回文件描述符
    int CreateServer(uint16_t port=8888) 
    {
        bool ret = _socket.CreateServer(port);
        assert(ret == true);
        return _socket.Fd();
    }
private:
    Socket _socket;     // 监听套接字
    EventLoop *_loop;   // 回指向loop
    Channel _channel;   // 连接的事件管理
    AcceptCallBack _accept_cb;  // 设置新连接要执行的操作
};
// 服务器
class TcpServer 
{
    using PtrConnection = std::shared_ptr<Connection>;
    using ConnectedCallBack = std::function<void(const PtrConnection&)>;
    using MessageCallBack = std::function<void(const PtrConnection&, Buffer *)>;
    using ClosedCallBack = std::function<void(const PtrConnection&)>;
    using AnyEventCallBack = std::function<void(const PtrConnection&)>;
    using Functor = std::function<void()>;
public:
    TcpServer(uint16_t port=8888)
    :_port(port),_acceptor(&_baseloop, port),_pool(&_baseloop) 
    {
        lg(Info,"SIGPIPE INIT"); signal(SIGPIPE, SIG_IGN);
        _acceptor.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        // 将监听套接字挂到baseloop上
        _acceptor.Listen();
    }
    // 设置线程池数量
    void SetThreadPoolSize(int count) {return _pool.SetThreadPoolSize(count);}
    // 定义时间为timeout的非活跃连接释放
    void SetInactiveRelease(int timeout) {_timeout = timeout; _enable_inactive_release = true;}
    // 添加定时任务
    void RunAfter(const Functor &task, int delay) 
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    // 启动服务器
    void Start() {_pool.Init(); _baseloop.Start();}
    // 设置连接之后的各种回调
    void SetConnectedCallBack(const ConnectedCallBack&cb) {_connected_cb=cb;}
    void SetMessageCallBack(const MessageCallBack&cb) {_message_cb=cb;}
    void SetClosedCallBack(const ClosedCallBack&cb) {_closed_cb=cb;}
    void SetAnyEventCallBack(const AnyEventCallBack&cb) {_event_cb=cb;}

private:
    // 为新连接构造connetion对象
    void NewConnection(int fd) 
    {
        _next_id++;
        PtrConnection conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallBack(_message_cb);
        conn->SetClosedCallBack(_closed_cb);
        conn->SetConnectedCallBack(_connected_cb);
        conn->SetAnyEventCallBack(_event_cb);
        conn->SetSrvClosedCallBack(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release) conn->SetInactiveRelease(_timeout);//启动非活跃超时销毁
        conn->Established();//就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }
    // 添加定时器任务
    void RunAfterInLoop(const Functor &task, int delay) 
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    // 从_conns中移除连接
    void RemoveConnectionInLoop(const PtrConnection &conn) 
    {
        int id = conn->Id();
        auto it = _conns.find(id);
        if (it != _conns.end()) _conns.erase(it);
        else std::cout<<__LINE__,abort();
    }
    //从管理Connection的_conns中移除连接信息
    void RemoveConnection(const PtrConnection &conn) 
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }
private:
    uint64_t _next_id=0;    // 连接和定时器id,使用一次自动增长
    uint16_t _port=8888;    // 服务器端口号
    int _timeout;           // 超时销毁时间
    EventLoop _baseloop;    // 主Reactor
    Acceptor _acceptor;     // 管理监听套接字  
    LoopThreadPool _pool;   // 从属Reactor线程池
    std::unordered_map<uint64_t, PtrConnection> _conns;//保存管理所有连接对应的shared_ptr对象
    bool _enable_inactive_release=false; // 是否启动非活跃连接释放
    ConnectedCallBack _connected_cb;     // 连接成功后的回调
    MessageCallBack _message_cb;         // 业务处理回调
    ClosedCallBack _closed_cb;           // 释放连接回调
    AnyEventCallBack _event_cb;          // 任意事件回调
};


